Accessing the Camera and Capturing Photos Using AVFoundation

Course: iOS App Development

Topic: Accessing the Camera and Capturing Photos Using AVFoundation

Course Link: iOS App Development Training – JustAcademy

Demo Link: Register for a Free Course Demo

Website: JustAcademy Official Website

1. Introduction to Camera Access in iOS

Camera access is an important feature in modern iOS applications. It allows users to capture photographs, scan documents, take profile pictures, scan QR codes, and create visual content directly inside an application.

Apple provides the AVFoundation framework for working with camera hardware and media capture. AVFoundation gives developers control over camera devices, capture sessions, photo outputs, video previews, and capture settings.

Using AVFoundation, developers can build a custom camera interface instead of relying only on the default iOS Camera application. This makes it possible to create camera experiences that match the design and functionality of an application.

In this topic, you will learn how to request camera permission, configure an AVCaptureSession, display a live camera preview, capture photographs using AVCapturePhotoOutput, and handle the captured image data.

2. Learning Objectives

• Understand the purpose of the AVFoundation framework.
• Learn the basic architecture of camera capture in iOS.
• Request camera permission from users.
• Configure camera privacy descriptions in Info.plist.
• Access front and rear camera devices.
• Create and configure an AVCaptureSession.
• Connect camera input and photo output.
• Display a live camera preview.
• Capture photographs using AVCapturePhotoOutput.
• Handle captured image data using delegate methods.
• Save captured photographs to the Photos library.
• Understand camera errors and troubleshooting techniques.

3. What Is AVFoundation?

AVFoundation is an Apple framework used to work with audiovisual media on supported Apple platforms. It provides APIs for capturing, processing, playing, and managing audio and video content.

In iOS camera development, AVFoundation provides the components required to communicate with the device camera and receive captured image data.

3.1 Important Features of AVFoundation

• Access front-facing and rear-facing cameras.
• Configure camera capture sessions.
• Display a live camera preview.
• Capture still photographs.
• Record video and audio.
• Configure flash and supported camera settings.
• Capture different image formats.
• Process image data and metadata.
• Support advanced photography features on compatible devices.

3.2 Importing AVFoundation

To use AVFoundation APIs in a Swift file, import the framework:

import AVFoundation

For a UIKit-based camera interface, you may also need UIKit and Photos:

import UIKit
import AVFoundation
import Photos

4. Understanding the AVFoundation Camera Architecture

AVFoundation uses a capture pipeline. The camera device provides media input, a capture session coordinates the flow, and capture outputs process or deliver the resulting media.

4.1 Main AVFoundation Components

4.2 Camera Capture Workflow

1. Request permission to access the camera.
2. Check whether camera access is authorized.
3. Select the required camera device.
4. Create an AVCaptureDeviceInput.
5. Create an AVCaptureSession.
6. Add the camera input to the session.
7. Add an AVCapturePhotoOutput to the session.
8. Configure and start the capture session.
9. Display the live camera preview.
10. Capture a photograph using AVCapturePhotoOutput.
11. Process the captured image data.
12. Display or save the photograph.

5. Checking Camera Availability

Before configuring a camera session, check whether the required camera hardware is available. Different iPhone and iPad models may provide different camera configurations.

5.1 Accessing the Rear Camera

import AVFoundation

func getRearCamera() -> AVCaptureDevice? {
    return AVCaptureDevice.default(
        .builtInWideAngleCamera,
        for: .video,
        position: .back
    )
}

5.2 Accessing the Front Camera

func getFrontCamera() -> AVCaptureDevice? {
    return AVCaptureDevice.default(
        .builtInWideAngleCamera,
        for: .video,
        position: .front
    )
}

The camera position determines which physical camera the application attempts to use. Always check whether the selected device exists before creating an input.

6. Configuring Camera Privacy Permission

iOS protects user privacy by requiring applications to request permission before accessing the camera. The application must explain why it needs camera access through a privacy usage description.

6.1 Add NSCameraUsageDescription to Info.plist

Open the application's Info.plist file and add the following key:

NSCameraUsageDescription

Example description:

Privacy - Camera Usage Description:
This app requires camera access to capture photographs.

In the Xcode property list editor, the key appears as Privacy - Camera Usage Description. Its underlying Info.plist key is NSCameraUsageDescription.

Important: If an application attempts to access the camera without providing the required usage description, iOS can terminate the application.

6.2 Understanding Camera Authorization Status

7. Requesting Camera Permission Using Swift

Use AVCaptureDevice authorization APIs to check the current camera permission status and request access when necessary.

7.1 Permission Request Example

import AVFoundation

func requestCameraPermission(
    completion: @escaping (Bool) -> Void
) {
    switch AVCaptureDevice.authorizationStatus(for: .video) {

    case .authorized:
        completion(true)

    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .video) { granted in
            DispatchQueue.main.async {
                completion(granted)
            }
        }

    case .denied, .restricted:
        completion(false)

    @unknown default:
        completion(false)
    }
}

7.2 Using the Permission Function

requestCameraPermission { granted in
    if granted {
        print("Camera permission granted.")
        // Start camera configuration.
    } else {
        print("Camera permission unavailable.")
        // Show an appropriate permission message.
    }
}

Permission should be requested at a suitable point in the user experience. Explain why camera access is required before presenting the system permission prompt.

8. Creating an AVCaptureSession

AVCaptureSession is the central component of the AVFoundation capture architecture. It coordinates the connection between camera input devices and media outputs.

For a basic photo capture application, the session connects one camera input with one photo output.

8.1 Creating the Session

import AVFoundation

let captureSession = AVCaptureSession()

8.2 Setting the Session Preset

A session preset determines the general quality and resolution configuration used by the capture session.

captureSession.sessionPreset = .photo

The photo preset is suitable for a still-photography workflow. The selected preset must be supported by the configured capture devices and outputs.

9. Adding Camera Input to the Session

AVCaptureDeviceInput connects a physical camera device to an AVCaptureSession. The input allows the session to receive camera data.

9.1 Creating Camera Input

guard let camera = AVCaptureDevice.default(
    .builtInWideAngleCamera,
    for: .video,
    position: .back
) else {
    print("Rear camera is unavailable.")
    return
}

do {
    let cameraInput = try AVCaptureDeviceInput(device: camera)

    if captureSession.canAddInput(cameraInput) {
        captureSession.addInput(cameraInput)
    }
} catch {
    print("Unable to create camera input: \(error.localizedDescription)")
}

9.2 Why Use canAddInput()?

The canAddInput() method checks whether the capture session can accept the proposed input. Checking before adding an input helps prevent invalid session configurations.

10. Adding AVCapturePhotoOutput

AVCapturePhotoOutput is used to capture still photographs. It supports common photo capture workflows and additional features such as Live Photos, RAW capture, and other supported photography capabilities.

10.1 Creating Photo Output

let photoOutput = AVCapturePhotoOutput()

if captureSession.canAddOutput(photoOutput) {
    captureSession.addOutput(photoOutput)
}

10.2 Configuring the Capture Session

captureSession.beginConfiguration()

captureSession.sessionPreset = .photo

// Add supported camera input and photo output here.

captureSession.commitConfiguration()

Use beginConfiguration() and commitConfiguration() when changing session inputs, outputs, or related configuration. This allows changes to be applied as a coordinated configuration update.

11. Starting and Stopping the Camera Session

After configuring the input and output, the application can start the capture session. Starting the session enables the camera data flow and allows the preview to display live camera content.

11.1 Starting the Session

captureSession.startRunning()

11.2 Stopping the Session

captureSession.stopRunning()

Starting and stopping a capture session can take time. Perform these operations on a dedicated serial session queue instead of blocking the main interface thread.

12. Displaying a Live Camera Preview

A camera preview allows users to see what the camera is pointing at before taking a photograph. AVFoundation provides AVCaptureVideoPreviewLayer for displaying this live camera feed.

12.1 Creating a Preview Layer

let previewLayer = AVCaptureVideoPreviewLayer(
    session: captureSession
)

previewLayer.videoGravity = .resizeAspectFill

12.2 Adding the Preview Layer to a UIView

class CameraPreviewView: UIView {

    override class var layerClass: AnyClass {
        AVCaptureVideoPreviewLayer.self
    }

    var videoPreviewLayer: AVCaptureVideoPreviewLayer {
        return layer as! AVCaptureVideoPreviewLayer
    }

    func configure(with session: AVCaptureSession) {
        videoPreviewLayer.session = session
        videoPreviewLayer.videoGravity = .resizeAspectFill
    }
}

This custom UIView uses AVCaptureVideoPreviewLayer as its backing layer. It can be added to a camera screen and connected to the capture session.

12.3 Understanding videoGravity

13. Capturing Photos Using AVCapturePhotoOutput

Once the camera preview is running, the user can capture a photograph by calling the capturePhoto(with:delegate:) method.

Each capture request uses an AVCapturePhotoSettings object to define the settings for that photograph. A delegate receives callbacks when the capture operation completes or encounters an error.

13.1 Creating Photo Settings

let photoSettings = AVCapturePhotoSettings()

photoOutput.capturePhoto(
    with: photoSettings,
    delegate: photoCaptureDelegate
)

Use a new AVCapturePhotoSettings instance for each capture request. Do not reuse a settings instance that has already been used for a capture.

13.2 Implementing AVCapturePhotoCaptureDelegate

class PhotoCaptureDelegate: NSObject,
                            AVCapturePhotoCaptureDelegate {

    var completion: ((UIImage?) -> Void)?

    init(completion: @escaping (UIImage?) -> Void) {
        self.completion = completion
    }

    func photoOutput(
        _ output: AVCapturePhotoOutput,
        didFinishProcessingPhoto photo: AVCapturePhoto,
        error: Error?
    ) {
        if let error = error {
            print("Photo capture error: \(error.localizedDescription)")
            completion?(nil)
            return
        }

        guard let imageData = photo.fileDataRepresentation(),
              let image = UIImage(data: imageData) else {
            print("Unable to create image from captured data.")
            completion?(nil)
            return
        }

        DispatchQueue.main.async {
            self.completion?(image)
        }
    }
}

The delegate receives the completed photo data. The fileDataRepresentation() method provides image data that can be used to display, process, or save the captured photograph.

14. Building a Capture Photo Button

A camera screen generally includes a capture button that starts the photo capture operation when the user taps it.

14.1 Capture Button Action

@IBAction func capturePhotoButtonTapped(_ sender: UIButton) {

    let settings = AVCapturePhotoSettings()

    let delegate = PhotoCaptureDelegate { image in
        guard let image = image else {
            print("Photo capture failed.")
            return
        }

        self.imageView.image = image
    }

    self.photoCaptureDelegate = delegate

    photoOutput.capturePhoto(
        with: settings,
        delegate: delegate
    )
}

In this example, photoCaptureDelegate should be a retained property of the camera controller. Keeping a strong reference to the delegate ensures that it remains available while the asynchronous capture operation is in progress.

15. Complete Camera Controller Example

The following example combines camera permission handling, session configuration, camera preview, and photo capture in a UIKit-based application. It is a teaching example and should be adapted to the app's view lifecycle, error presentation, and interface design.

import UIKit
import AVFoundation

class CameraViewController: UIViewController {

    private let captureSession = AVCaptureSession()
    private let photoOutput = AVCapturePhotoOutput()

    private var previewLayer: AVCaptureVideoPreviewLayer?
    private var photoCaptureDelegate: PhotoCaptureDelegate?

    private let sessionQueue = DispatchQueue(
        label: "com.example.camera.session"
    )

    @IBOutlet weak var previewView: UIView!
    @IBOutlet weak var capturedImageView: UIImageView!

    override func viewDidLoad() {
        super.viewDidLoad()
        checkCameraPermission()
    }

    override func viewDidLayoutSubviews() {
        super.viewDidLayoutSubviews()
        previewLayer?.frame = previewView.bounds
    }

    private func checkCameraPermission() {
        switch AVCaptureDevice.authorizationStatus(for: .video) {

        case .authorized:
            configureCamera()

        case .notDetermined:
            AVCaptureDevice.requestAccess(for: .video) {
                granted in

                if granted {
                    self.configureCamera()
                } else {
                    print("Camera permission denied.")
                }
            }

        case .denied, .restricted:
            print("Camera access is unavailable.")

        @unknown default:
            print("Unknown camera permission status.")
        }
    }

    private func configureCamera() {
        sessionQueue.async {
            self.captureSession.beginConfiguration()
            self.captureSession.sessionPreset = .photo

            guard let camera = AVCaptureDevice.default(
                .builtInWideAngleCamera,
                for: .video,
                position: .back
            ) else {
                self.captureSession.commitConfiguration()
                return
            }

            do {
                let input = try AVCaptureDeviceInput(
                    device: camera
                )

                if self.captureSession.canAddInput(input) {
                    self.captureSession.addInput(input)
                } else {
                    self.captureSession.commitConfiguration()
                    return
                }

                if self.captureSession.canAddOutput(self.photoOutput) {
                    self.captureSession.addOutput(self.photoOutput)
                } else {
                    self.captureSession.commitConfiguration()
                    return
                }

                self.captureSession.commitConfiguration()

                DispatchQueue.main.async {
                    let preview = AVCaptureVideoPreviewLayer(
                        session: self.captureSession
                    )

                    preview.videoGravity = .resizeAspectFill
                    preview.frame = self.previewView.bounds

                    self.previewView.layer.addSublayer(preview)
                    self.previewLayer = preview
                }

                self.captureSession.startRunning()

            } catch {
                self.captureSession.commitConfiguration()
                print("Camera setup error: \(error.localizedDescription)")
            }
        }
    }

    @IBAction func capturePhotoTapped(_ sender: UIButton) {
        let settings = AVCapturePhotoSettings()

        let delegate = PhotoCaptureDelegate { image in
            guard let image = image else {
                return
            }

            self.capturedImageView.image = image
        }

        photoCaptureDelegate = delegate

        photoOutput.capturePhoto(
            with: settings,
            delegate: delegate
        )
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)

        sessionQueue.async {
            if self.captureSession.isRunning {
                self.captureSession.stopRunning()
            }
        }
    }
}

Implementation note: In a production camera controller, handle setup failures explicitly, coordinate session startup with preview layout, and ensure that session configuration is not performed concurrently from multiple queues. The capture output and session should be managed through a consistent lifecycle.

16. Switching Between Front and Rear Cameras

Many camera applications allow users to switch between the front and rear cameras. To switch cameras, remove the existing input and add a new input for the selected camera.

16.1 Example Camera Switching Function

func switchCamera(to position: AVCaptureDevice.Position) {
    sessionQueue.async {
        guard let newCamera = AVCaptureDevice.default(
            .builtInWideAngleCamera,
            for: .video,
            position: position
        ) else {
            return
        }

        do {
            let newInput = try AVCaptureDeviceInput(
                device: newCamera
            )

            self.captureSession.beginConfiguration()

            if let currentInput = self.captureSession.inputs
                .compactMap({ $0 as? AVCaptureDeviceInput })
                .first {
                self.captureSession.removeInput(currentInput)
            }

            if self.captureSession.canAddInput(newInput) {
                self.captureSession.addInput(newInput)
            }

            self.captureSession.commitConfiguration()

        } catch {
            print("Camera switching failed: \(error.localizedDescription)")
        }
    }
}

For a production implementation, preserve the previous input and restore it if the new input cannot be added. Also consider device discovery APIs when selecting cameras with advanced hardware capabilities.

17. Configuring Flash Settings

Some camera devices support flash functionality. AVFoundation allows developers to configure flash behavior for individual photo capture requests.

17.1 Checking Flash Availability

if let camera = AVCaptureDevice.default(for: .video) {
    print("Flash available: \(camera.hasFlash)")
}

17.2 Setting Flash Mode

let settings = AVCapturePhotoSettings()

if photoOutput.supportedFlashModes.contains(.auto) {
    settings.flashMode = .auto
}

Common flash modes include:

• Auto: The camera decides whether flash is needed.
• On: Requests flash for the capture when supported.
• Off: Captures without flash.

Always check device and output support before selecting a flash mode. Front-facing cameras may not provide a physical flash.

18. Saving Captured Photos to the Photos Library

After capturing a photograph, an application may allow the user to save it to the device's Photos library. PhotoKit provides APIs for creating and managing photo assets.

18.1 Configure Photo Library Permission

If your app uses PhotoKit to save captured photos, configure an appropriate privacy usage description in Info.plist.

NSPhotoLibraryAddUsageDescription

Example description:

Privacy - Photo Library Additions Usage Description:
This app needs permission to save captured photos to your library.

For workflows that also read or browse existing library content, configure the appropriate read/write access description and request the required authorization. Use the least access needed for the feature.

18.2 Saving an Image Using PhotoKit

import Photos

func savePhotoToLibrary(_ image: UIImage) {
    PHPhotoLibrary.requestAuthorization(for: .addOnly) {
        status in

        guard status == .authorized || status == .limited else {
            print("Photo library access is unavailable.")
            return
        }

        PHPhotoLibrary.shared().performChanges {
            PHAssetChangeRequest.creationRequestForAsset(
                from: image
            )
        } completionHandler: { success, error in

            if success {
                print("Photo saved successfully.")
            } else {
                print("Photo save failed: \(error?.localizedDescription ?? "Unknown error")")
            }
        }
    }
}

For an AVFoundation photo capture workflow, another recommended approach is to use AVCapturePhoto.fileDataRepresentation() and a PHAssetCreationRequest to preserve the captured photo data and supported metadata.

19. Handling Captured Image Data

AVCapturePhoto provides access to the result of a photo capture request. The application can convert the photo data into a UIImage for display or use the original data for storage and further processing.

19.1 Converting Photo Data into UIImage

if let imageData = photo.fileDataRepresentation(),
   let capturedImage = UIImage(data: imageData) {
    imageView.image = capturedImage
}

19.2 Displaying the Captured Image

DispatchQueue.main.async {
    self.imageView.image = capturedImage
}

UI updates should happen on the main thread. For larger images, consider memory usage, resizing, and image processing requirements before displaying or uploading the image.

20. Camera Focus and Exposure Controls

Advanced camera applications may allow users to adjust focus and exposure. AVCaptureDevice provides properties and methods for controlling supported camera behavior.

20.1 Configuring Focus

do {
    try camera.lockForConfiguration()

    if camera.isFocusModeSupported(.continuousAutoFocus) {
        camera.focusMode = .continuousAutoFocus
    }

    camera.unlockForConfiguration()

} catch {
    print("Unable to configure camera focus.")
}

20.2 Configuring Exposure

do {
    try camera.lockForConfiguration()

    if camera.isExposureModeSupported(.continuousAutoExposure) {
        camera.exposureMode = .continuousAutoExposure
    }

    camera.unlockForConfiguration()

} catch {
    print("Unable to configure camera exposure.")
}

Always check whether a device supports the requested mode. Lock the device configuration only for the time needed to apply the changes, and unlock it afterward.

21. Understanding Photo Formats and Quality

AVCapturePhotoOutput supports different photo formats depending on device capabilities and capture settings. Common workflows use JPEG or HEIF, while supported devices may also offer RAW capture.

Do not assume every format or advanced capture feature is supported by every device. Check the capabilities exposed by AVCapturePhotoOutput before configuring a capture request.

22. Common Camera Errors and Troubleshooting

22.1 Camera Permission Denied

Problem: The application cannot access the camera because the user denied permission.

Solution: Display a helpful message explaining how to enable camera access through the iOS Settings app. Do not repeatedly request permission after the system has recorded a denial.

22.2 Camera Device Not Found

Problem: The requested front or rear camera is unavailable.

Solution: Check the result of the camera discovery call and provide a fallback interface if the requested device is not available.

22.3 Capture Session Cannot Add Input

Problem: The selected camera input cannot be added to the session.

Solution: Use canAddInput() before adding the input. Verify session configuration and device availability.

22.4 Capture Session Cannot Add Output

Problem: The photo output cannot be connected to the capture session.

Solution: Check canAddOutput() and confirm that the selected session configuration supports the intended output.

22.5 Black Camera Preview

Problem: The camera preview appears black or does not display live content.

Solution:

• Verify that camera permission is authorized.
• Confirm that the camera input was added successfully.
• Check that the capture session is running.
• Verify that the preview layer uses the correct session.
• Ensure the preview layer has a valid frame and is visible in the view hierarchy.

22.6 Captured Photo Is Not Displayed

Problem: The capture operation completes but no image appears.

Solution: Check the delegate error, confirm that fileDataRepresentation() returns valid data, and update the UIImageView on the main thread.

22.7 Application Crashes When Accessing Camera

Problem: The app terminates when attempting to use camera functionality.

Solution: Verify that NSCameraUsageDescription is present in Info.plist and that camera access is requested before configuring the capture session.

23. Best Practices for Camera Development

• Request camera permission only when the feature needs it.
• Explain the reason for camera access clearly.
• Always check camera availability before creating an input.
• Use a dedicated serial queue for capture session configuration and lifecycle operations.
• Avoid blocking the main thread with session startup or shutdown.
• Check input and output compatibility before adding them to the session.
• Retain photo capture delegate objects until capture callbacks complete.
• Handle capture errors and unavailable hardware gracefully.
• Stop the camera session when the camera screen is no longer active.
• Respect user privacy and avoid capturing photographs without clear user interaction.
• Use appropriate image formats and manage large image memory carefully.
• Check device support before enabling advanced capture features.
• Test camera behavior on physical devices with different hardware capabilities.

24. Practical Project: Custom Camera Application

Create a simple iOS camera application that allows users to view a live camera preview, capture photographs, review the captured image, and save it to the Photos library.

Project Requirements

• Create a new iOS project using Swift and UIKit or SwiftUI.
• Add the AVFoundation framework.
• Configure the camera privacy usage description.
• Request camera permission from the user.
• Access the rear-facing camera.
• Configure an AVCaptureSession.
• Add an AVCaptureDeviceInput.
• Add an AVCapturePhotoOutput.
• Display the live camera preview.
• Add a capture photo button.
• Implement AVCapturePhotoCaptureDelegate.
• Display the captured photograph.
• Add an option to save the image to the Photos library.
• Display appropriate error messages when camera access is unavailable.

Expected Result

The application should display a live camera preview after permission is granted. When the user taps the capture button, the application should capture a photograph, display the resulting image, and provide an option to save it to the device's Photos library.

25. Practice Exercises

1. Create an iOS project and import AVFoundation.
2. Add NSCameraUsageDescription to Info.plist.
3. Write a function to request camera permission.
4. Check whether the front and rear cameras are available.
5. Create an AVCaptureSession and configure its photo preset.
6. Add a camera input using AVCaptureDeviceInput.
7. Add AVCapturePhotoOutput to the session.
8. Display the camera preview using AVCaptureVideoPreviewLayer.
9. Capture a photograph using AVCapturePhotoSettings.
10. Implement the photo capture delegate.
11. Display the captured image in a UIImageView.
12. Save the captured photograph using PhotoKit.
13. Add a button to switch between front and rear cameras.
14. Test permission-denied and unavailable-camera scenarios.

26. Interview Questions and Answers

Q1. What is AVFoundation?

AVFoundation is an Apple framework used to capture, process, and manage audiovisual media, including photos, video, and audio.

Q2. What is AVCaptureSession?

AVCaptureSession coordinates the flow of media from capture inputs, such as cameras, to capture outputs, such as photo or video outputs.

Q3. What is AVCaptureDevice?

AVCaptureDevice represents a physical or virtual media capture device, such as a front-facing or rear-facing camera.

Q4. What is AVCaptureDeviceInput?

AVCaptureDeviceInput connects a selected camera device to an AVCaptureSession.

Q5. What is AVCapturePhotoOutput?

AVCapturePhotoOutput is the AVFoundation component used to capture still photographs and supported advanced photography formats.

Q6. What is AVCaptureVideoPreviewLayer?

It displays the live camera feed from an AVCaptureSession inside the application's interface.

Q7. Why is NSCameraUsageDescription required?

It explains why the application needs camera access and is required by iOS for camera privacy authorization.

Q8. How do you request camera permission?

Use AVCaptureDevice.requestAccess(for: .video) after checking the current authorization status.

Q9. What is the purpose of AVCapturePhotoSettings?

It defines the capture configuration for an individual photograph, including supported options such as flash mode and output format.

Q10. What is AVCapturePhotoCaptureDelegate?

It provides callbacks for the photo capture process, including the callback that delivers the processed photograph.

Q11. What does startRunning() do?

It starts the capture session and enables media flow from configured inputs to outputs.

Q12. What does stopRunning() do?

It stops the capture session and ends its active media flow.

Q13. How can you switch between front and rear cameras?

Find the required camera device, create a new AVCaptureDeviceInput, and update the session configuration by removing the old input and adding the new one.

Q14. How do you save captured photos to the Photos library?

Use PhotoKit APIs such as PHPhotoLibrary and PHAssetCreationRequest, with the appropriate user authorization.

Q15. Why should camera session operations use a background queue?

Session configuration and startup operations can take time. Using a dedicated serial queue helps prevent the user interface from freezing.

27. Quick Revision Checklist

• AVFoundation imported into the project.
• NSCameraUsageDescription added to Info.plist.
• Camera permission requested and checked.
• Camera device selected successfully.
• AVCaptureDeviceInput created and added.
• AVCaptureSession configured correctly.
• AVCapturePhotoOutput added to the session.
• AVCaptureVideoPreviewLayer displays the live preview.
• AVCapturePhotoSettings created for each capture.
• Photo capture delegate implemented and retained.
• Captured image data processed successfully.
• PhotoKit authorization configured if saving to the library.
• Camera session stopped when no longer required.
• Errors and unsupported device configurations handled safely.

28. Official Learning Resources

• Apple AVFoundation Documentation
• Setting Up a Capture Session
• Capturing Still and Live Photos
• AVCapturePhotoOutput Reference
• Saving Captured Photos
• Apple PhotoKit Documentation

29. Conclusion

Accessing the camera and capturing photographs using AVFoundation is an essential skill for iOS developers who want to build applications with custom camera functionality. By understanding AVCaptureSession, AVCaptureDeviceInput, AVCapturePhotoOutput, and AVCaptureVideoPreviewLayer, developers can create a complete photo capture workflow.

Camera permission handling, session configuration, photo capture delegates, image processing, and PhotoKit integration are important parts of a reliable camera application. Practical implementation and testing on physical devices help developers understand camera behavior and handle different hardware and permission scenarios.

Explore iOS App Development Training: View iOS Course | Register for a Free Demo | Visit JustAcademy